package PaqServidor;

import PaqCORBA.ClienteCORBA;
import PaqCORBA.GestorExamenCORBA;
import PaqComunicaciones.CorbaConexionServidor;
import java.util.ArrayList;

public class Sesion extends PaqCORBA.SesionCORBAPOA{
    public GestorExaminador gestor;
    private String nombre;
    public Profesor pf = new Profesor();
    public Alumno al = new Alumno();
    protected CorbaConexionServidor corbaConexionServidor;
    protected ClienteCORBA ClienteCORBA;
    private GestorExamenCORBA gestorCORBA;
    

    public Sesion(GestorExaminador _gestor, String _nombre, PaqComunicaciones.CorbaConexionServidor corbaCS) 
    {
        gestor = _gestor;
        nombre = _nombre;
        corbaConexionServidor = corbaCS;
        // registrar el sirviente con el nombre de la sesion
        corbaConexionServidor.registrarSesion(this, nombre);
        // Cliente sin resolver: debo esperar a que lo registre el cliente
        // con el nombre que le devolvera ExamenesOnline.entrar() que ha llamado
        // a este constructor
        ClienteCORBA = null;
    }
    
    public void enviaAviso(String info) {
        // Si no lo ha resuelto todavia -> Resuelve el cliente
        if (ClienteCORBA == null) {
            String nombreCliente = new String(nombre + "Cliente");
            ClienteCORBA = corbaConexionServidor.resolverCliente(nombreCliente);
        }
        //ClienteCORBA.aviso(info);
    }
    
    
    public void salir() 
    {
        //gestor.delSesion(this);
        // eliminar el sirviente con el nombre de la sesion
        corbaConexionServidor.desregistrar(nombre);
    }
    
    
    @Override
    public PaqCORBA.Usuario validar(String usuario, String Password)
    {        
        PaqCORBA.Usuario u = gestor.validar(usuario, Password);
        
        if ( u.tipo.equals("Profesor" ) )
        {
            pf = new Profesor(u.user, u.password, u.nombre);

            for ( int i = 0; i < u.asignaturas.length; i++ )
            {
                pf.lasignaturas.add(new Asignatura(u.asignaturas[i].nombre));
                for ( int j = 0; j < u.asignaturas[i].temas.length; j++) {
                    Tema t = new Tema();
                    t.CORBAToThis(u.asignaturas[i].temas[j]);
                    pf.lasignaturas.get(i).ltemas.add(t);
                }
            }
        }
        else if(u.tipo.equals("Alumno"))
        {
            al = new Alumno(u.user, u.password, u.nombre);
            
            for ( PaqCORBA.Asignatura a: u.asignaturas )
            {
                al.lasignaturas.add(new Asignatura(a.nombre));    
            }  
        }
        else
            System.out.println("Sesion - validar: no escribo usuarios");
        return u;
    }
       
    /**
     * 
     * Descripción: método que añade una Pregunta al sistema.
     * @param pf: Usuario que añade la Pregunta
     * @param enunciado: enunciado de la Pregunta.
     * @param numRespuestas: número de respuestas posibles que tiene la Pregunta.
     * @param respuestas: lista de respuestas posibles que tiene la Pregunta.
     * @param tema: tema de la asignatura al que pertenece la Pregunta.
     */
    @Override
    public void addPregunta (String enunciado, short numRespuestas, PaqCORBA.RespuestaPosible[] respuestas, String tema, String asig)
    {
        pf.addPregunta(enunciado, numRespuestas, respuestas, tema, asig);
        
        // Actualizamos los datos en gestor
        /*for(int i=0; i<gestor.prof_t.size(); i++)
            if ( gestor.prof_t.get(i).getNombre().equals(pf.getNombre()) )
            {
                //System.out.println("Sesion -- addPregunta: " + pf.listaPreguntas.get(i).getEnunciado());
                for ( Pregunta p : pf.findAsignatura(asig).findTema(tema).listaPreguntas )
                {
                    //gestor.prof_t.get(i).listaPreguntas.add(p);
                    gestor.prof_t.get(i).findAsignatura(asig).findTema(tema).listaPreguntas.add(p);    
                }
            }*/
        
        //volcamos los nuevos datos en un fichero, en formato xml
        gestor.realizarBackup();
    }
    
    /**
     * 
     * Descripción: método utilizado para editar el contenido de una pregunta.
     * @param pf: Usuario que edita la pregunta.
     * @param idpregunta: identificador de la Pregunta.
     * @param enunciado: nuevo valor del enunciado de la pregunta.
     * @param numRespuestas: nuevo valor del número de respuestas de la pregunta
     * @param respuestas: nuevo valor de las respuesta asociadas a dicha Pregunta.
     * @param tema: nuevo valor del Tema al que pertenece la Pregunta.
     */
    @Override
    public void editPregunta (String asig, String old_enunciado, String new_enunciado, short numRespuestas, String[] respuestas, boolean[] oks, String tema)
    {
        pf.editPregunta(asig, old_enunciado, new_enunciado, numRespuestas, respuestas, oks, tema);
        gestor.realizarBackup();
    }
 
    /**
     * 
     * Descripción: método utilizado para borrar una Pregunta y sus Respuestas asociadas.
     * @param pf: Usuario que borra la Pregunta.
     * @param idPregunta: identificador de la Pregunta.
     */
    @Override
    public void borrarPregunta (String asig, String tema, String Pregunta)
    {
        pf.borrarPregunta(asig, tema, Pregunta);
        gestor.realizarBackup();
    }
    
    /**
     * 
     * Descripción: método utilizado para listar los examenes.
     * @param user: Usuario que reclama la lista.
     * @return: devuelve la lista de Examenes que tiene asociado.
     */
    @Override
    public String[] listarExamenes()
    {
        if (al != null) {
            return al.listarExamenes();
        }
        else {
            return pf.listarExamenes();
        }
    }
    
    /**
     * 
     * Descripción: método utilizado para poner un examen a los alumnos.
     * @param fechaIni: fecha de comienzo del examen.
     * @param fechaFin: fecha tope para hacer el examen.
     * @param asignatura: valor de la Asignatura del examen.
     * @param temas: valor del array con los Temas que abarca el examen.
     * @param numPreguntas: valor con el número de preguntas que posee el examen.
     */
    @Override
    public void ponerExamen(String fechaIni, String fechaFin, short numPreguntas, String asignatura, String[] temas) throws PaqCORBA.exDemasiadasPreguntas
    {
        ExamenProfesor ex = pf.ponerExamen(fechaIni, fechaFin, numPreguntas, asignatura, temas);
        
        for ( Profesor p: gestor.prof_t )
            if ( p.getNombre().equals(pf.getNombre()) )
                p.listaExProf.add(ex);
        gestor.realizarBackup();
    }
    
    /**
     * 
     * Descripción: método utilizado para responder un examen.
     * @param alu: Usuario que responde a un examen.
     * @param respuesta: valor de la respuesta marcada.
     */
    @Override
    public void responder (short respuesta, PaqCORBA.ExamenAlumno exAlu)
    {
        Alumno alumno = new Alumno(al.user, al.password, al.nombre);
        
        alumno.responder(respuesta);
    }
    
    /**
     * 
     * Descripción: método utilizado para generar un examen que va a realizar un alumno en particular.
     * @param examenSeleccionado: valor del examen seleccionado por el alumno.
     * @return: devuelve el examen generado por el sistema para que lo resuelva el alumno.
     */
    @Override
    public PaqCORBA.ExamenAlumno generarExamenAlumno (PaqCORBA.ExamenProfesor examenSeleccionado)
    {
        ExamenProfesor examen = null;
        ExamenAlumno exAlu = null;
        PaqCORBA.ExamenAlumno ex = new PaqCORBA.ExamenAlumno(null, exAlu.getNota());
        //examen.setId(examenSeleccionado.id);
        examen.setFecha_inicio(examenSeleccionado.fecha_inicio);
        examen.setFecha_fin(examenSeleccionado.fecha_fin);
        
        exAlu = examen.generarExamenAlumno();
        
        //ex.id = exAlu.getId();
        ex.nota = exAlu.getNota();
        for (int i=0; i<exAlu.getContestacion().size(); i++) {
            ex.cont[i] = (short)Integer.parseInt(exAlu.getContestacion().get(i).toString());
        }
        return ex;
        
    } 
  
    @Override
    public String[] listarTemas (String asignatura)
    {
        if(pf != null) {
            return pf.listarTemas(asignatura);
        } else {
            return al.listarTemas(asignatura);
        }
    }


    @Override
    public String[] listarAsignaturas ()
    {     
        if (pf != null)
            return pf.listarAsignaturas();
        else
            return al.listarAsignaturas();

    }
    
    @Override
    public String[] listarPreguntas (String tema, String asig) {
        if (pf != null)
            return pf.listarPreguntas(tema, asig);
        else
            return al.listarPreguntas(tema, asig);
  }
  
    @Override
    public String[] listarRespuestasDescripcion (String tema, String asig, String pregunta) {
        if(pf != null)
            return pf.listarRespuestasDescripcion(tema, asig, pregunta);
        else
            return al.listarRespuestasDescripcion(tema, asig, pregunta);
    }
    
    @Override
    public boolean[] listarRespuestasCorrecta (String tema, String asig, String pregunta) {
        if(pf != null)
            return pf.listarRespuestasCorrecta(tema, asig, pregunta);
        else
            return al.listarRespuestasCorrecta(tema, asig, pregunta);
    }
  
}